经典算法之图的广度优先搜索遍历

/************************
author's email:wardseptember@gmail.com
data:2017.12.14
图的广度优先搜索遍历
************************/
/*
图的广度优先搜索遍历（BFS）类似于树的程序遍历。它的基本思想是：首先访问起始顶点v,然后选取
与v邻接的全部顶点w1...wn进行访问，再依次访问与w1,....,wn邻接的全部顶点（已经访问过的
除外），以此类推，直到所有顶点都被访问完。
*/
#include<iostream>
#define maxSize 8
using namespace std;
typedef struct Node {
	int vertex;
	struct Node *pNext;
}Node;
typedef struct head {
	char data;
	Node *first;
}head, *Graph;
int visit[maxSize];       //定义一个全局变量，用来判断某一结点是否被访问过
Graph create_graph();    //创建一个邻接表
void BFS(Graph graph, int v,int visit[maxSize]); //广度遍历连通图
void bfs(Graph graph);       //广度遍历非连通图
void BFSTrave(Graph graph, int i, int j);//判断顶点i和顶点j（i!=j）之间是否有路径
int main() {
	Graph graph = create_graph();
	cout << "广度遍历连通图结果为：";
	BFS(graph, 7,visit);	//Bfs(graph);广度遍历非连通图
	cout << endl;

	int i, j;
	cout << "请输入要判断的两个顶点(0-7):";
	cin >> i >> j;
	BFSTrave(graph, i, j);
	return 0;
}
Graph create_graph()
{
	//为保存顶点相关信息的数组分配空间，并对数据域赋值
	Graph graph = (Graph)malloc(maxSize * sizeof(head));
	int i;
	//顶点的序号按照输入顺序从0依次向后
	for (i = 0; i < maxSize; i++)
		graph[i].data = 'A' + i;

	//为每个节点对应的的单链表中的节点分配空间
	Node *p00 = (Node *)malloc(sizeof(Node));
	Node *p01 = (Node *)malloc(sizeof(Node));
	Node *p10 = (Node *)malloc(sizeof(Node));
	Node *p11 = (Node *)malloc(sizeof(Node));
	Node *p12 = (Node *)malloc(sizeof(Node));
	Node *p20 = (Node *)malloc(sizeof(Node));
	Node *p21 = (Node *)malloc(sizeof(Node));
	Node *p22 = (Node *)malloc(sizeof(Node));
	Node *p30 = (Node *)malloc(sizeof(Node));
	Node *p31 = (Node *)malloc(sizeof(Node));
	Node *p40 = (Node *)malloc(sizeof(Node));
	Node *p41 = (Node *)malloc(sizeof(Node));
	Node *p50 = (Node *)malloc(sizeof(Node));
	Node *p51 = (Node *)malloc(sizeof(Node));
	Node *p60 = (Node *)malloc(sizeof(Node));
	Node *p61 = (Node *)malloc(sizeof(Node));
	Node *p70 = (Node *)malloc(sizeof(Node));
	Node *p71 = (Node *)malloc(sizeof(Node));

	//为各单链表中的节点的相关属性赋值
	p00->vertex = 1;
	p00->pNext = p01;
	p01->vertex = 2;
	p01->pNext = NULL;
	p10->vertex = 0;
	p10->pNext = p11;
	p11->vertex = 3;
	p11->pNext = p12;
	p12->vertex = 4;
	p12->pNext = NULL;
	p20->vertex = 0;
	p20->pNext = p21;
	p21->vertex = 5;
	p21->pNext = p22;
	p22->vertex = 6;
	p22->pNext = NULL;
	p30->vertex = 1;
	p30->pNext = p31;
	p31->vertex = 7;
	p31->pNext = NULL;
	p40->vertex = 1;
	p40->pNext = p41;
	p41->vertex = 7;
	p41->pNext = NULL;
	p50->vertex = 2;
	p50->pNext = p51;
	p51->vertex = 6;
	p51->pNext = NULL;
	p60->vertex = 2;
	p60->pNext = p61;
	p61->vertex = 5;
	p61->pNext = NULL;
	p70->vertex = 3;
	p70->pNext = p71;
	p71->vertex = 4;
	p71->pNext = NULL;

	//将顶点与每个单链表连接起来
	graph[0].first = p00;
	graph[1].first = p10;
	graph[2].first = p20;
	graph[3].first = p30;
	graph[4].first = p40;
	graph[5].first = p50;
	graph[6].first = p60;
	graph[7].first = p70;

	return graph;
}
void BFS(Graph graph, int v, int visit[maxSize]) {//广度优先遍历连通图
	Node *p;
	int que[maxSize], front = 0, rear = 0;//定义一个顺序队，并初始化
	int j;
	cout << graph[v].data<<' ';
	visit[v] = 1;
	rear = (rear + 1) % maxSize;    //v入队
	que[rear] = v;
	while (front != rear) {   //对空说明遍历完成
		front = (front + 1) % maxSize;   //顶点出队
		j = que[front];
		p = graph[j].first;      //p指向出队顶点j的第一条边
		while (p != NULL) {     //将p的所有邻接点中未被访问的入队
			if (visit[p->vertex] == 0) {//当前邻接顶点未被访问，则进队
				cout << graph[p->vertex].data<<' ';
				visit[p->vertex] = 1;
				rear = (rear + 1) % maxSize;//该顶点进队
				que[rear] = p->vertex;
			}
			p = p->pNext;       //p指向j的下一条边
		}
	}
}
void bfs(Graph graph) {   //广度优先遍历非连通图
	int i;
	for (i = 0; i < maxSize; ++i)
		if (visit[i] == 0)
			BFS(graph, i,visit);
}
void BFSTrave(Graph graph, int i, int j) {//判断顶点i和顶点j（i!=j）之间是否有路径
	int k;
	for (k = 0; k < maxSize; ++k)
		visit[k] = 0;
	BFS(graph, i, visit);
	cout << endl;
	if (visit[j] == 1)//visit[j]=1则证明访问过程遇到了j
		cout << "两顶点间有路径" << endl;
	else
		cout << "两顶点间无路径" << endl;
}